home *** CD-ROM | disk | FTP | other *** search
/ Aminet 5 / Aminet 5 - March 1995.iso / Aminet / util / cli / MJoin.lha / MJoin.c < prev    next >
C/C++ Source or Header  |  1995-01-29  |  10KB  |  468 lines
  1. #include <exec/types.h>            /* BOOL etc. Type-Definitions     */
  2. #include <dos/dos.h>               /* Definition of RETURN_FAIL etc. */
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <ctype.h>
  8.  
  9. /* Konstanten -------------------------------------------------------------------------- */
  10.  
  11. #define MISSING_BASENAME    1
  12. #define FROM_NOT_LEGAL        2
  13. #define UPTO_NOT_LEGAL        3
  14. #define FROM_TOO_LOW            4
  15. #define UPTO_TOO_LOW            5
  16. #define WRONG_PARAMETERS    6
  17. #define MISSING_ASNAME        7
  18. #define MISSING_WILDCARD  8
  19. /* --------------------- */
  20. #define PARSE_ERROR       8
  21. /* --------------------- */
  22. #define FILE_EXISTS                9
  23. #define NO_MEMORY        10
  24.  
  25.  
  26. /* Funktions-Protos -------------------------------------------------------------------- */
  27.  
  28. BOOL   LetztesFile(int, char *);
  29. char * MakeFileName(int);
  30. void   WrongArgs(char *);
  31. char * CutWildCard(char *);
  32. char * Uppercase(char *);
  33. void   PrintError(int);
  34. BOOL   fileexist(char *);
  35.  
  36.  
  37. /* Globale Variablen ------------------------------------------------------------------- */
  38.  
  39. char * basename;
  40. char * asname = NULL;
  41. const char * wildcard = "*";
  42. int    from = 0;
  43. int    upto = -1;
  44. BOOL   nofrac = FALSE;
  45. BOOL   doublenull = FALSE;
  46. BOOL   quiet = FALSE;
  47. BOOL   force = FALSE;
  48. BOOL   add = FALSE;
  49.  
  50. /* main -------------------------------------------------------------------------------- */
  51.  
  52. int main(int ArgC, char * ArgV[])
  53. {
  54.     int    arg = 1;                                                /* Aktuelle Argumentnummer */
  55.     int    filenr;                        /* Aktuelle Nummer des bearbeiteten Files */
  56.     int    zeichen;                       /* Zeichen-Transfer-Puffer */
  57.     int    WCpos = 0;                     /* Dient zum finden des Wildcards */
  58.     int    baselen = 0;                   /* Länge des Basenames */
  59.     BOOL   ready = FALSE;                 /* Schleifenabbruchs-Boolean */
  60.     BOOL   error = FALSE;                 /* TRUE, falls Joining abgebrochen */
  61.     BOOL   givenasname = FALSE;           /* TRUE, wenn AsName vom Benutzer kommt */
  62.     FILE * Asfp = NULL;                   /* Output-FilePointer */
  63.     FILE * Infp = NULL;                   /* Input-FilePointer */
  64.     char * actualfilename = NULL;         /* Name des aktuellen Files */
  65.     
  66.     /* ------------------------ Parsing ------------------------- */
  67. /*fs*/
  68.     if(1 == ArgC)                        /* keine Parameter ist unzulässig */
  69.     {
  70.         PrintError(MISSING_BASENAME);
  71.         WrongArgs(ArgV[0]);
  72.     }
  73.  
  74.     /* BaseName-Parameter */
  75.     basename = ArgV[arg];
  76.     arg++;
  77.     baselen = strlen(basename);
  78.     /* WildCard finden, Stelle in WCpos */
  79.     for(WCpos = 0; WCpos <=baselen; WCpos++)
  80.     {
  81.         if(wildcard[0] == basename[WCpos]) break;
  82.     }
  83.     if(WCpos > baselen)
  84.     {
  85.         PrintError(MISSING_WILDCARD);
  86.         WrongArgs(ArgV[0]);
  87.     }
  88.  
  89.     /* FROM-Parameter */
  90.     if(arg+2 <= ArgC && 0 == strcmp("FROM", Uppercase(ArgV[arg]) ))
  91.     {
  92.         if(!isdigit(ArgV[arg+1][0]) ) 
  93.         {
  94.             PrintError(FROM_NOT_LEGAL);
  95.             WrongArgs(ArgV[0]);
  96.         }
  97.         from = atoi(ArgV[++arg]);
  98.         if(0 > from)
  99.         {
  100.             PrintError(FROM_TOO_LOW);
  101.             WrongArgs(ArgV[0]);
  102.         }
  103.         arg++;
  104.     } 
  105.  
  106.     /* UPTO-Parameter */
  107.     if(arg+2 <= ArgC && 0 == strcmp("UPTO", Uppercase(ArgV[arg]) ))
  108.     {
  109.         if(!isdigit(ArgV[arg+1][0]) )
  110.         {
  111.             PrintError(UPTO_NOT_LEGAL);
  112.             WrongArgs(ArgV[0]);
  113.         }
  114.         upto = atoi(ArgV[++arg]);
  115.         if(-1 != upto)
  116.         {
  117.             if(upto <= from) 
  118.             {
  119.                 PrintError(UPTO_TOO_LOW);
  120.                 WrongArgs(ArgV[0]);
  121.             }
  122.         }
  123.         arg++;
  124.     } 
  125.     
  126.     /* ASName-Parameter */
  127.     if(arg+2 <= ArgC && 0 == strcmp("AS", Uppercase(ArgV[arg]) ))
  128.     {
  129.         asname = ArgV[++arg];
  130.         arg++;
  131.     } 
  132.  
  133.     while(!ready && arg+1 <= ArgC)          /* Abfrage der drei Booleans */
  134.     {
  135.         /* NOFRAC-Parameter */
  136.         if(arg+1 <= ArgC && 0 == strcmp("NOFRAC", Uppercase(ArgV[arg]) ))
  137.         {
  138.             nofrac = TRUE;
  139.             arg++;
  140.         }
  141.  
  142.         /* NULL-Parameter */
  143.         else if(arg+1 <= ArgC && 0 == strcmp("NULL", Uppercase(ArgV[arg]) ))
  144.         {
  145.             doublenull = TRUE;
  146.             arg++;
  147.         }
  148.  
  149.         /* QUIET-Parameter */
  150.         else if(arg+1 <= ArgC && 0 == strcmp("QUIET", Uppercase(ArgV[arg]) ))
  151.         {
  152.             quiet = TRUE;
  153.             arg++;
  154.         }
  155.  
  156.         /* FORCE-Parameter */
  157.         else if(arg+1 <= ArgC && 0 == strcmp("FORCE", Uppercase(ArgV[arg]) ))
  158.         {
  159.             force = TRUE;
  160.             arg++;
  161.         }
  162.  
  163.         /* ADD-Parameter */
  164.         else if(arg+1 <= ArgC && 0 == strcmp("ADD", Uppercase(ArgV[arg]) ))
  165.         {
  166.             add = TRUE;
  167.             arg++;
  168.         }
  169.  
  170.         /* Müll-Parameter führt zum Ende */
  171.         else 
  172.         {
  173.             PrintError(WRONG_PARAMETERS);
  174.             ready = TRUE;
  175.         }
  176.     }
  177.     
  178.     if(arg != ArgC) WrongArgs(ArgV[0]);                   /* mind. ein  Parameter ungültig */
  179.  
  180.     if(0 == strcmp(wildcard, basename) && NULL == asname) /* WildCard-BaseName, aber kein AsName */
  181.     {
  182.         PrintError(MISSING_ASNAME);
  183.         WrongArgs(ArgV[0]);
  184.     }
  185.  
  186.     if(NULL == asname)
  187.     {
  188.         givenasname = TRUE;
  189.         asname = CutWildCard(basename);    /* Default-AsName ist der Basename ohne WildCard*/
  190.     }
  191. /* --------------------------------------------------------------------------------------- */
  192. /*fe*/
  193.  
  194.     if(!quiet) printf("\n  MJoin V1.1 by Harald Löffler\n\n");
  195.     
  196.     if(!fileexist(asname) || force)
  197.     {
  198.         filenr = from;
  199.         do
  200.         {
  201.             actualfilename = MakeFileName(filenr);
  202.             if(!quiet) printf("    %s", actualfilename);
  203.             if(fileexist(actualfilename))
  204.             {
  205.  
  206.                 /* hier muß das Joining stattfinden */
  207.  
  208.                 if(add)
  209.                 {
  210.                     if(!Asfp)    Asfp = fopen(asname, "a");
  211.                 }
  212.                 else
  213.                 {
  214.                     if(!Asfp)    Asfp = fopen(asname, "w");
  215.                 }
  216.  
  217.                 Infp = fopen(actualfilename, "r");
  218.  
  219.                 while(EOF != (zeichen = getc(Infp)))
  220.                 {
  221.                     putc(zeichen, Asfp);
  222.                 }
  223.  
  224.                 if(Infp) fclose(Infp);
  225.  
  226.                 /* Ende Joining                     */
  227.  
  228.                 if(!quiet) printf("\tJoined\n");
  229.             }
  230.             else
  231.             {
  232.                 if(-1 != upto && nofrac) error = TRUE;
  233.                 if(!quiet) printf("\tNot found\n");
  234.             }
  235.         
  236.             ready = LetztesFile(filenr, actualfilename);
  237.             free(actualfilename);
  238.             filenr++;
  239.         }
  240.         while(!ready);
  241.     }
  242.     else
  243.     {
  244.         if(!quiet) PrintError(FILE_EXISTS);
  245.         exit(RETURN_WARN);
  246.     }
  247.  
  248.     /* Am Ende das EOF und Schließen des AsFiles nicht vergessen */
  249.     if(Asfp)    fclose(Asfp);
  250.   if(!givenasname) free(asname);
  251.     if(!quiet) printf("\n");
  252.     if(error)
  253.     {
  254.         if(!quiet) printf("  Joining aborted!\n\n");
  255.         exit(RETURN_WARN);
  256.     }
  257.     else
  258.     {
  259.         exit(RETURN_OK);
  260.     }
  261. }
  262.  
  263. /* Funktionen -------------------------------------------------------------------------- */
  264.  
  265. BOOL LetztesFile(int number, char * filename)
  266. /*fs*/
  267. {
  268.     if(nofrac || -1 == upto)
  269.     {
  270.         return((BOOL)!fileexist(filename));
  271.     }
  272.     else
  273.     {
  274.         return((BOOL)!(number < upto));
  275.     }
  276. }
  277. /*fe*/
  278.  
  279. char * MakeFileName(int number)
  280. /*fs*/
  281. {
  282.     char * str;
  283.   char * frontpart;
  284.   char * rearpart;
  285.   int    WCpos = 0;
  286.     int    nrlen = 1;
  287.     int    baselen = 0;
  288.     int    dummy = 0;
  289.     int    step = 0;
  290.  
  291.     dummy = number;
  292.     while(dummy > 9)
  293.     {
  294.         dummy /=10;
  295.         nrlen++;
  296.     }
  297.  
  298.     baselen = strlen(basename);
  299.  
  300.     /* WildCard finden, Stelle in WCpos */
  301.     for(WCpos = 0; WCpos <=baselen; WCpos++)
  302.     {
  303.         if(wildcard[0] == basename[WCpos]) break;
  304.     }
  305.  
  306.     frontpart = (char *) malloc(WCpos + 1);
  307.     if(NULL == frontpart)
  308.     {
  309.       printf("\n  MJoin V1.1 by Harald Löffler\n\n");
  310.         PrintError(NO_MEMORY);
  311.         exit(RETURN_FAIL);
  312.     }
  313.  
  314.     rearpart = (char *) malloc(baselen - WCpos);
  315.     if(NULL == rearpart)
  316.     {
  317.       printf("\n  MJoin V1.1 by Harald Löffler\n\n");
  318.         PrintError(NO_MEMORY);
  319.         exit(RETURN_FAIL);
  320.     }
  321.  
  322.     if(doublenull && number < 10) nrlen++;
  323.  
  324.     str = (char *)malloc(baselen + nrlen + 1);
  325.     if(NULL == str)
  326.     {
  327.       printf("\n  MJoin V1.1 by Harald Löffler\n\n");
  328.         PrintError(NO_MEMORY);
  329.         exit(RETURN_FAIL);
  330.     }
  331.  
  332.     /* frontpart kopieren */
  333.     for(step = 0; step < WCpos; step++)
  334.     {
  335.         frontpart[step] = basename[step];
  336.     }
  337.   frontpart[WCpos] = NULL;
  338.     
  339.     /* rearpart kopieren */
  340.     for(step = WCpos+1; step < baselen; step++)
  341.     {
  342.         rearpart[step-WCpos-1] = basename[step];
  343.     }
  344.   rearpart[baselen-WCpos-1] = NULL;    
  345.  
  346.     if(doublenull && number < 10)
  347.     {
  348.         sprintf(str, "%s0%i%s", frontpart, number, rearpart);
  349.     }
  350.     else
  351.     {
  352.         sprintf(str, "%s%i%s", frontpart, number, rearpart);
  353.     }
  354.   free(rearpart);
  355.   free(frontpart);
  356.     return(str);
  357. }
  358. /*fe*/
  359.  
  360. void WrongArgs(char * progname)
  361. /*fs*/
  362. {
  363.     printf("\nUSAGE: %s <basename>\t[FROM start] [UPTO end] [AS newname]\n\t\t\t[NOFRAC|NULL|QUIET|FORCE|ADD]\n\n", progname);
  364.     exit(RETURN_WARN);
  365. }
  366. /*fe*/
  367.  
  368. char * CutWildCard(char *name)
  369. /*fs*/
  370. {
  371.     char * retname = NULL;
  372.     int i = 0;
  373.     int j = 0;
  374.     
  375.     retname = (char *) malloc(strlen(name) + 1);
  376.     if(NULL == retname)
  377.     {
  378.       printf("\n  MJoin V1.1 by Harald Löffler\n\n");
  379.         PrintError(NO_MEMORY);
  380.         exit(RETURN_FAIL);
  381.     }
  382.     
  383.  
  384.     for(i=0, j=0 ; i < strlen(name); i++)
  385.     {
  386.         if(wildcard[0] != name[i])
  387.             retname[j++] = name[i];    
  388.     }
  389.     retname[j] = NULL;
  390.     return(retname);
  391. }
  392. /*fe*/
  393.  
  394. char * Uppercase(char * str)
  395. /*fs*/
  396. {
  397.     int i = -1;
  398.     while(str[++i] != NULL) str[i] = toupper(str[i]);
  399.     return(str);
  400. }
  401. /*fe*/
  402.  
  403. void PrintError(int error)
  404. /*fs*/
  405. {
  406.     if(error <= PARSE_ERROR && !quiet)
  407.       printf("\n  MJoin V1.1 by Harald Löffler\n");
  408.     if(!(error > PARSE_ERROR && quiet))
  409.     {
  410.         switch(error)
  411.         {
  412.             case MISSING_BASENAME:
  413.                 printf("\n  I need at least a basename!\n");
  414.                 break;
  415.             case FROM_NOT_LEGAL:
  416.                 printf("\n  FROM-Value is not a legal number.\n");            
  417.                 break;
  418.             case UPTO_NOT_LEGAL:
  419.                 printf("\n  FROM-Value is not a legal number.\n");
  420.                 break;
  421.             case FROM_TOO_LOW:
  422.                 printf("\n  FROM-Value must be greater then zero.\n");
  423.                 break;
  424.             case UPTO_TOO_LOW:
  425.                 printf("\n  UPTO-Value must be greater then FROM-Value.\n");
  426.                 break;
  427.             case WRONG_PARAMETERS:
  428.                 printf("\n  One or more wrong Parameter(s)!\n");
  429.                 break;
  430.             case MISSING_ASNAME:
  431.                 printf("\n  I need an AsName!\n");
  432.                 break;
  433.             case MISSING_WILDCARD:
  434.                 printf("\n  Where is the wildcard? :-|\n");
  435.                 break;
  436.             case FILE_EXISTS:
  437.                 printf("  AsName allready exists. Use FORCE to overwrite.\n\n");
  438.                 break;
  439.             case NO_MEMORY:
  440.               printf("  Cannot allocate new memory. Abort.\n\n");
  441.               break;
  442.         }
  443.     }
  444. }
  445. /*fe*/
  446.  
  447. BOOL fileexist(char * file)
  448. /*fs*/
  449. {
  450.     FILE * fp = NULL;
  451.     BOOL   ret = FALSE;
  452.  
  453.     fp = fopen(file,"r");
  454.  
  455.     if(NULL == fp)
  456.     {
  457.         ret = FALSE;
  458.     }
  459.     else
  460.     {
  461.         ret = TRUE;
  462.     }
  463.  
  464.     if(fp) fclose(fp);
  465.     return(ret);
  466. }
  467. /*fe*/
  468.